Minkowski's Convex Body Theorem and Integer Programming

Supported by NSF grant ECS-8418392 I n t r o d u c t i o n The Integer Programming (feasibility) Problem is the problem of determining whether there is a vector of integers satisfying a given system of linear inequalities. In settling an important open problem, H.W.Lenstra (1981,1983) showed in an elegant way that when n the number of variables is fixed, there is a polynomial t ime algorithm to solve this problem. He accomplishes this by giving a polynomial t ime algorithm that for any polytope P in Z either finds an integer point (point with all integer coordinates) in P or finds an integer vector v so that the maximum value of (v ,x ) and the minimum value of (v,x) over the polytope P differ by less than c where c is a constant independent of n. Every integer point must lie on a hyperplane of the form (v ,x ) = z for some integer 2, and there are at most c* such hyperplanes intersecting P. It obviously suffices to determine for each such hyperplane JB", whether H n P contains an integer point. Lenstra uses this to show that an n variable problem can be reduced to c problems each in n — 1 variables. This raises two questions : Can we effectively reduce an n variable problem to polynomially many n — 1 variable problems ? Can the reduction be done efficiently so as to achieve a better complexity for Integer Programming ? Both these questions are answered affirmatively in this paper. If an n variable problem is reduced to polynomially many n — 1 variable problems, the best complexity we can achieve is n for some constant c, so we are at liberty to take this amount of t ime for the reduction to one less variable. Furthermore, the same result is obviously achieved if we reduce an n variable problem to problems in n — i variables for some i between 1 and n. Indeed, the greater the t the better since then we reduce the number of variables by a larger amount. This paper presents an algorithm which either finds an integer point in the given polytope P in Z or finds for some i, 1 < i < n, an n — i dimensional subspace V with the following property : the number of translates of V containing integer points that intersect P is at most n * \ Each such translate leads to a n — i dimensional problem. So, it can be shown that there is a factor of 0 ( n 5 / 2 ) per variable in the running time. In this sense, it reduces an n variable problem effectively to 0 ( n 5 / 2 ) problems in n — 1 variables. The algorithm for finding the subspace V uses at most 0(ns) arithmetic operations where s is the length of description of the polytope. The dependence on n of the complete integer programming algorithm is shown to be O(n). This paper is the final journal version of the preliminary paper Kannan (1983). Since the appearance of the preliminary version, Hastad (1985) has observed using results of Lenstra and Schnorr (1984) that for any polytope P of positive volume in £ n , if P does not contain an integer point, then, there exists an integer vector v such that the maximum and minimum of (v, x) over P differ by at most 0 ( n 5 / 2 ) . This is an interesting existence result. But , there is no finite algorithm known that with P as input either gives us an integer point in P or the vector v. If we relax the 0 ( n 5 ^ 2 ) to 0 ( n 3 ) , then we can get such an algorithm using the techniques of this paper ; it uses 0(ns) arithmetic operations. This gives a way of reducing an n variable Integer Program to 0(n) problems in n — 1 variables. However, the resulting algorithm for Integer Programming has, obviously, asymptotically worse complexity, so it is not presented here. This paper uses several concepts and results from Geometry of Numbers, the most crucial of them being Minkowski's convex body theorem. This elegant classical theorem turns out to be crucial in effectively reducing an n variable problem to polynomially many n — 1 variable problems rather than an exponential number of them. Section 1 contains a brief introduction to Geometry of Numbers to make the paper self-contained for Operations Researchers and Computer Scientists. The integer programming algorithm will be presented after two other algorithms : one for finding the shortest (in Euclidean length) non-zero integer linear combination of a given set of vectors and the other for finding the integer linear combination of a set of vectors that is closest (in Euclidean distance) to another given vector. These are called the Shortest Vector Problem (SVP) and the Closest Vector Problem (CVP) respectively. The algorithms for both problems take 0(ns) arithmetic operations on n dimensional problems where s is the length of the input. The algorithm for the SVP is needed as a subroutine in the integer programming algorithm whereas the algorithm for the CVP is not directly needed, but has ideas that will be useful in integer programming. It is well-known that Integer Programming is NP-hard. It has been shown recently that C V P is NP-hard. At present, it is not known whether SVP is NP-hard or admits a polynomial t ime algorithm (or both !). The last section of the paper provides another, more natural proof that C V P is NP-hard. Further, it relates the complexity of the SVP to an approximate version of the CVP. It is hoped that this is a beginning towards proving the NP-hardness of the S V P which remains an important open problem. S u m m a r y o f t h e p a p e r Operations Researchers are usually interested in solving the Integer Programming Optimality problem i.e., the problem of maximizing a linear function over the set of integer solutions (solutions wi th all integer coordinates) to a system of linear inequalities. This question can be reduced by elementary means to the Integer Programming feasibility question which is the problem of determining whether there is an integer point inside a given polyhedron. This paper deals only wi th the feasibility question and this will be called t h e I n t e g e r P r o g r a m m i n g P r o b l e m . Computationally it can be stated as : Given m x n and m x 1 matrices A and b respectively of integers, find whether there exists an n x 1 vector x of integers satisfying the m inequalities Ax < b. The case of n = 1 can be trivially solved in polynomial t ime. For the case of n = 2, Hirschberg and Wong (1976), Kannan (1980) and Scarf (1981) gave polynomial t ime algorithms. Central to H. W.Lenstra's algorithm for general n is an algorithm for finding a "reduced basis " of a "lattice"(both terms to be explained later). Lenstra's (1981) original basis reduction algorithm takes polynomial-time only when the number of dimensions is fixed. After his result, Lovasz devised a basis reduction algorithm which runs in polynomial time even when n the number of dimensions varies . This algorithm combined with an earlier result of A.K.Lenstra's (1981) that reduced factoring a polynomial to finding a short vector